| Package | Code Size | Bugs | Bugs p1 | Bugs p2 | Bugs p3 | Bugs Exp. | Ratio |
|---|---|---|---|---|---|---|---|
| Overall (2369 packages), (34363 classes) | 2243248 | 1905 | 1905 | ||||
| 216 | 4 | 4 | |||||
| com.iplanet.jato | 1739 | 2 | 2 | ||||
| com.iplanet.jato.model.object | 1758 | 3 | 3 | ||||
| com.iplanet.jato.taglib | 1227 | 1 | 1 | ||||
| com.iplanet.jato.view | 4217 | 1 | 1 | ||||
| com.iplanet.jato.view.command | 521 | 1 | 1 | ||||
| com.sun.appserv.ejb | 30 | 1 | 1 | ||||
| com.sun.appserv.management.alert | 193 | 2 | 2 | ||||
| com.sun.appserv.naming | 289 | 2 | 2 | ||||
| com.sun.appserv.security | 326 | 2 | 2 | ||||
| com.sun.connector.jaxr | 576 | 1 | 1 | ||||
| com.sun.corba.ee.impl.activation | 1574 | 3 | 3 | ||||
| com.sun.corba.ee.impl.codegen | 4120 | 7 | 7 | ||||
| com.sun.corba.ee.impl.io | 3026 | 1 | 1 | ||||
| com.sun.corba.ee.impl.javax.rmi.CORBA | 285 | 2 | 2 | ||||
| com.sun.corba.ee.impl.logging | 11801 | 1 | 1 | ||||
| com.sun.corba.ee.impl.naming.cosnaming | 724 | 4 | 4 | ||||
| com.sun.corba.ee.impl.naming.pcosnaming | 563 | 4 | 4 | ||||
| com.sun.corba.ee.impl.oa.rfm | 289 | 1 | 1 | ||||
| com.sun.corba.ee.impl.orb | 2218 | 2 | 2 | ||||
| com.sun.corba.ee.impl.orbutil | 3277 | 3 | 3 | ||||
| com.sun.corba.ee.impl.presentation.rmi | 1511 | 2 | 2 | ||||
| com.sun.corba.ee.impl.protocol | 2544 | 1 | 1 | ||||
| com.sun.corba.ee.org.apache.bcel | 1305 | 11 | 11 | ||||
| com.sun.corba.ee.org.apache.bcel.generic | 5704 | 6 | 6 | ||||
| com.sun.corba.ee.org.apache.bcel.util | 2045 | 3 | 3 | ||||
| com.sun.corba.ee.org.apache.bcel.verifier | 920 | 2 | 2 | ||||
| com.sun.corba.ee.org.apache.bcel.verifier.structurals | 3223 | 5 | 5 | ||||
| com.sun.corba.ee.org.objectweb.asm.attrs | 160 | 1 | 1 | ||||
| com.sun.corba.ee.org.objectweb.asm.tree.analysis | 1306 | 2 | 2 | ||||
| com.sun.corba.ee.org.objectweb.asm.util | 1939 | 1 | 1 | ||||
| com.sun.corba.ee.spi.codegen | 937 | 1 | 1 | ||||
| com.sun.corba.ee.spi.orb | 733 | 1 | 1 | ||||
| com.sun.corba.ee.spi.orbutil.fsm | 270 | 1 | 1 | ||||
| com.sun.corba.ee.spi.orbutil.newtimer | 296 | 1 | 1 | ||||
| com.sun.data.provider | 255 | 2 | 2 | ||||
| com.sun.data.provider.impl | 3425 | 5 | 5 | ||||
| com.sun.ejb.base.container.util | 58 | 1 | 1 | ||||
| com.sun.ejb.base.distributed | 34 | 1 | 1 | ||||
| com.sun.ejb.base.io | 303 | 2 | 2 | ||||
| com.sun.ejb.base.sfsb | 312 | 1 | 1 | ||||
| com.sun.ejb.base.sfsb.initialization | 173 | 1 | 1 | ||||
| com.sun.ejb.base.sfsb.store | 284 | 2 | 2 | ||||
| com.sun.ejb.base.stats | 1217 | 1 | 1 | ||||
| com.sun.ejb.codegen | 2303 | 2 | 2 | ||||
| com.sun.ejb.containers | 9950 | 8 | 8 | ||||
| com.sun.ejb.containers.builder | 162 | 1 | 1 | ||||
| com.sun.ejb.containers.util | 282 | 1 | 1 | ||||
| com.sun.ejb.containers.util.cache | 1504 | 1 | 1 | ||||
| com.sun.ejb.containers.util.pool | 653 | 1 | 1 | ||||
| com.sun.ejb.ee.sfsb.store | 3053 | 13 | 13 | ||||
| com.sun.ejb.ee.timer.lifecycle | 203 | 3 | 3 | ||||
| com.sun.ejb.portable | 164 | 1 | 1 | ||||
| com.sun.enterprise.addons | 625 | 1 | 1 | ||||
| com.sun.enterprise.admin | 443 | 4 | 4 | ||||
| com.sun.enterprise.admin.common | 2124 | 3 | 3 | ||||
| com.sun.enterprise.admin.common.domains.registry | 461 | 4 | 4 | ||||
| com.sun.enterprise.admin.config | 1174 | 1 | 1 | ||||
| com.sun.enterprise.admin.dottedname | 675 | 2 | 2 | ||||
| com.sun.enterprise.admin.event.pluggable | 36 | 1 | 1 | ||||
| com.sun.enterprise.admin.jmx.remote | 293 | 1 | 1 | ||||
| com.sun.enterprise.admin.jmx.remote.notification | 337 | 1 | 1 | ||||
| com.sun.enterprise.admin.mbeans | 6345 | 8 | 8 | ||||
| com.sun.enterprise.admin.meta | 1651 | 3 | 3 | ||||
| com.sun.enterprise.admin.meta.naming | 607 | 1 | 1 | ||||
| com.sun.enterprise.admin.monitor.registry | 294 | 2 | 2 | ||||
| com.sun.enterprise.admin.monitor.stats | 878 | 2 | 2 | ||||
| com.sun.enterprise.admin.selfmanagement.event | 2879 | 8 | 8 | ||||
| com.sun.enterprise.admin.server.core.jmx.nonssl | 36 | 1 | 1 | ||||
| com.sun.enterprise.admin.server.core.mbean.config | 4710 | 4 | 4 | ||||
| com.sun.enterprise.admin.servermgmt | 1614 | 6 | 6 | ||||
| com.sun.enterprise.admin.servermgmt.launch | 1573 | 2 | 2 | ||||
| com.sun.enterprise.admin.target | 385 | 2 | 2 | ||||
| com.sun.enterprise.admin.util | 1946 | 1 | 1 | ||||
| com.sun.enterprise.admin.verifier | 346 | 2 | 2 | ||||
| com.sun.enterprise.admin.verifier.tests | 1081 | 1 | 1 | ||||
| com.sun.enterprise.appclient | 1722 | 2 | 2 | ||||
| com.sun.enterprise.appclient.jws | 1767 | 3 | 3 | ||||
| com.sun.enterprise.cli.commands | 5470 | 6 | 6 | ||||
| com.sun.enterprise.cli.framework | 2491 | 10 | 10 | ||||
| com.sun.enterprise.config.impl | 694 | 1 | 1 | ||||
| com.sun.enterprise.connectors | 3182 | 6 | 6 | ||||
| com.sun.enterprise.connectors.authentication | 234 | 1 | 1 | ||||
| com.sun.enterprise.connectors.system | 1167 | 5 | 5 | ||||
| com.sun.enterprise.connectors.util | 2172 | 4 | 4 | ||||
| com.sun.enterprise.corba.ee.internal.util | 39 | 1 | 1 | ||||
| com.sun.enterprise.deployapi | 1456 | 7 | 7 | ||||
| com.sun.enterprise.deployapi.config | 173 | 2 | 2 | ||||
| com.sun.enterprise.deployment | 12147 | 45 | 45 | ||||
| com.sun.enterprise.deployment.annotation.factory | 95 | 1 | 1 | ||||
| com.sun.enterprise.deployment.annotation.handlers | 2047 | 1 | 1 | ||||
| com.sun.enterprise.deployment.archivist | 1508 | 8 | 8 | ||||
| com.sun.enterprise.deployment.autodeploy | 1225 | 7 | 7 | ||||
| com.sun.enterprise.deployment.backend | 3985 | 3 | 3 | ||||
| com.sun.enterprise.deployment.client | 1172 | 1 | 1 | ||||
| com.sun.enterprise.deployment.node | 2404 | 2 | 2 | ||||
| com.sun.enterprise.deployment.node.connector | 523 | 4 | 4 | ||||
| com.sun.enterprise.deployment.phasing | 2712 | 4 | 4 | ||||
| com.sun.enterprise.deployment.util | 1729 | 1 | 1 | ||||
| com.sun.enterprise.deployment.web | 343 | 55 | 55 | ||||
| com.sun.enterprise.diagnostics | 748 | 4 | 4 | ||||
| com.sun.enterprise.diagnostics.collect | 1430 | 2 | 2 | ||||
| com.sun.enterprise.diagnostics.util | 534 | 2 | 2 | ||||
| com.sun.enterprise.ee.admin | 165 | 2 | 2 | ||||
| com.sun.enterprise.ee.admin.hadbmgmt | 2709 | 4 | 4 | ||||
| com.sun.enterprise.ee.cms.lifecycle | 168 | 1 | 1 | ||||
| com.sun.enterprise.ee.deployment.phasing | 209 | 2 | 2 | ||||
| com.sun.enterprise.ee.diagnostics | 300 | 3 | 3 | ||||
| com.sun.enterprise.ee.diagnostics.collect | 283 | 1 | 1 | ||||
| com.sun.enterprise.ee.diagnostics.report.html | 73 | 1 | 1 | ||||
| com.sun.enterprise.ee.nodeagent | 1558 | 2 | 2 | ||||
| com.sun.enterprise.ee.nodeagent.mbeans | 91 | 1 | 1 | ||||
| com.sun.enterprise.ee.selfmanagement.actions | 1429 | 1 | 1 | ||||
| com.sun.enterprise.ee.util.concurrent | 397 | 2 | 2 | ||||
| com.sun.enterprise.ee.util.zip | 449 | 5 | 5 | ||||
| com.sun.enterprise.ee.web.authenticator | 2100 | 2 | 2 | ||||
| com.sun.enterprise.ee.web.sessmgmt | 10991 | 31 | 31 | ||||
| com.sun.enterprise.ee.web.stats | 166 | 1 | 1 | ||||
| com.sun.enterprise.iiop | 2515 | 4 | 4 | ||||
| com.sun.enterprise.iiop.security | 2070 | 15 | 15 | ||||
| com.sun.enterprise.instance | 2368 | 1 | 1 | ||||
| com.sun.enterprise.jbi.serviceengine.bridge | 417 | 2 | 2 | ||||
| com.sun.enterprise.jbi.serviceengine.comm | 793 | 1 | 1 | ||||
| com.sun.enterprise.jbi.serviceengine.core | 865 | 2 | 2 | ||||
| com.sun.enterprise.jxtamgmt | 2455 | 6 | 6 | ||||
| com.sun.enterprise.launcher | 432 | 1 | 1 | ||||
| com.sun.enterprise.log | 14 | 2 | 2 | ||||
| com.sun.enterprise.management.agent | 1048 | 1 | 1 | ||||
| com.sun.enterprise.management.model | 1263 | 8 | 8 | ||||
| com.sun.enterprise.repository | 1116 | 1 | 1 | ||||
| com.sun.enterprise.resource | 5229 | 2 | 2 | ||||
| com.sun.enterprise.resource.monitor | 420 | 1 | 1 | ||||
| com.sun.enterprise.security | 2354 | 11 | 11 | ||||
| com.sun.enterprise.security.acl | 364 | 1 | 1 | ||||
| com.sun.enterprise.security.audit | 269 | 1 | 1 | ||||
| com.sun.enterprise.security.auth | 507 | 2 | 2 | ||||
| com.sun.enterprise.security.auth.login | 470 | 3 | 3 | ||||
| com.sun.enterprise.security.factory | 99 | 2 | 2 | ||||
| com.sun.enterprise.security.jmac.callback | 342 | 1 | 1 | ||||
| com.sun.enterprise.security.jmac.config | 1476 | 4 | 4 | ||||
| com.sun.enterprise.server | 4393 | 4 | 4 | ||||
| com.sun.enterprise.server.logging | 1750 | 2 | 2 | ||||
| com.sun.enterprise.server.logging.logviewer.backend | 444 | 1 | 1 | ||||
| com.sun.enterprise.server.ondemand | 802 | 4 | 4 | ||||
| com.sun.enterprise.server.ss | 532 | 2 | 2 | ||||
| com.sun.enterprise.tools.admingui.handlers | 17895 | 1 | 1 | ||||
| com.sun.enterprise.tools.common.beans | 285 | 4 | 4 | ||||
| com.sun.enterprise.tools.common.util | 612 | 1 | 1 | ||||
| com.sun.enterprise.tools.common.util.diagnostics | 696 | 1 | 1 | ||||
| com.sun.enterprise.tools.upgrade | 395 | 1 | 1 | ||||
| com.sun.enterprise.tools.upgrade.certconversion | 1221 | 1 | 1 | ||||
| com.sun.enterprise.tools.upgrade.cluster | 440 | 1 | 1 | ||||
| com.sun.enterprise.tools.upgrade.common | 2785 | 1 | 1 | ||||
| com.sun.enterprise.tools.upgrade.gui | 2674 | 1 | 1 | ||||
| com.sun.enterprise.tools.verifier.apiscan.classfile | 1061 | 1 | 1 | ||||
| com.sun.enterprise.tools.verifier.apiscan.packaging | 416 | 2 | 2 | ||||
| com.sun.enterprise.tools.verifier.gui | 785 | 8 | 8 | ||||
| com.sun.enterprise.tools.verifier.tests.connector | 547 | 1 | 1 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb | 1243 | 1 | 1 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb.elements | 471 | 1 | 1 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb.runtime | 1078 | 4 | 4 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb.runtime.beancache | 216 | 3 | 3 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb.runtime.beanpool | 206 | 3 | 3 | ||||
| com.sun.enterprise.tools.verifier.tests.ejb.runtime.resource | 190 | 2 | 2 | ||||
| com.sun.enterprise.tools.verifier.tests.web.runtime | 1029 | 2 | 2 | ||||
| com.sun.enterprise.transaction | 319 | 2 | 2 | ||||
| com.sun.enterprise.util | 5556 | 4 | 4 | ||||
| com.sun.enterprise.util.collection | 1598 | 2 | 2 | ||||
| com.sun.enterprise.util.diagnostics | 1265 | 1 | 1 | ||||
| com.sun.enterprise.util.io | 864 | 1 | 1 | ||||
| com.sun.enterprise.util.pool | 727 | 1 | 1 | ||||
| com.sun.enterprise.web | 7206 | 2 | 2 | ||||
| com.sun.enterprise.web.ara.rules | 260 | 2 | 2 | ||||
| com.sun.enterprise.webservice | 3894 | 11 | 11 | ||||
| com.sun.enterprise.webservice.apt | 73 | 1 | 1 | ||||
| com.sun.enterprise.webservice.monitoring | 817 | 2 | 2 | ||||
| com.sun.faces.renderkit | 764 | 1 | 1 | ||||
| com.sun.genericra | 472 | 1 | 1 | ||||
| com.sun.genericra.monitoring | 194 | 1 | 1 | ||||
| com.sun.gjc.common | 177 | 1 | 1 | ||||
| com.sun.gjc.spi | 1454 | 1 | 1 | ||||
| com.sun.gjc.spi.base | 1476 | 3 | 3 | ||||
| com.sun.gjc.spi.jdbc40 | 684 | 5 | 5 | ||||
| com.sun.gjc.util | 136 | 1 | 1 | ||||
| com.sun.hadb.cli | 1782 | 3 | 3 | ||||
| com.sun.hadb.cli.adapter | 2444 | 2 | 2 | ||||
| com.sun.hadb.cli.framework | 2523 | 8 | 8 | ||||
| com.sun.hadb.jdbc | 8755 | 5 | 5 | ||||
| com.sun.hadb.jdbc.ds | 179 | 1 | 1 | ||||
| com.sun.hadb.jdbc.pool | 587 | 4 | 4 | ||||
| com.sun.hadb.mgt | 1528 | 1 | 1 | ||||
| com.sun.hadb.mgt.agent | 3965 | 1 | 1 | ||||
| com.sun.hadb.mgt.api | 4163 | 3 | 3 | ||||
| com.sun.hadb.mgt.cluma | 1985 | 3 | 3 | ||||
| com.sun.hadb.mgt.rema | 10119 | 5 | 5 | ||||
| com.sun.java.help.impl | 2627 | 5 | 5 | ||||
| com.sun.java.help.search | 4944 | 11 | 11 | ||||
| com.sun.jbi.framework | 4761 | 2 | 2 | ||||
| com.sun.jbi.management | 563 | 1 | 1 | ||||
| com.sun.jbi.management.registry | 486 | 1 | 1 | ||||
| com.sun.jbi.management.registry.data | 194 | 1 | 1 | ||||
| com.sun.jbi.management.repository | 583 | 1 | 1 | ||||
| com.sun.jbi.management.support | 613 | 1 | 1 | ||||
| com.sun.jbi.management.system | 3907 | 4 | 4 | ||||
| com.sun.jbi.management.util | 1318 | 2 | 2 | ||||
| com.sun.jbi.messaging | 2220 | 2 | 2 | ||||
| com.sun.jbi.ui.runtime.mbeans | 1874 | 4 | 4 | ||||
| com.sun.jbi.wsdl11wrapper | 292 | 1 | 1 | ||||
| com.sun.jbi.wsdl11wrapper.impl | 235 | 1 | 1 | ||||
| com.sun.jdmk | 3632 | 1 | 1 | ||||
| com.sun.jdmk.cascading | 458 | 2 | 2 | ||||
| com.sun.jdmk.comm | 11639 | 6 | 6 | ||||
| com.sun.jdmk.discovery | 1679 | 5 | 5 | ||||
| com.sun.jdmk.internal | 812 | 3 | 3 | ||||
| com.sun.jdo.api.persistence.enhancer.classfile | 3169 | 6 | 6 | ||||
| com.sun.jdo.api.persistence.model | 761 | 3 | 3 | ||||
| com.sun.jdo.spi.persistence.support.sqlstore.query.jqlc | 11857 | 2 | 2 | ||||
| com.sun.jdo.spi.persistence.utility.generator | 169 | 1 | 1 | ||||
| com.sun.jmx.remote.generic | 869 | 1 | 1 | ||||
| com.sun.jndi.toolkit.ctx | 1590 | 2 | 2 | ||||
| com.sun.jndi.url.jndi | 138 | 1 | 1 | ||||
| com.sun.jsftemplating.el | 923 | 1 | 1 | ||||
| com.sun.jsftemplating.layout.template | 794 | 1 | 1 | ||||
| com.sun.jsftemplating.util | 1059 | 1 | 1 | ||||
| com.sun.jts.CosTransactions | 9183 | 9 | 9 | ||||
| com.sun.jts.jta | 784 | 1 | 1 | ||||
| com.sun.jts.pi | 513 | 4 | 4 | ||||
| com.sun.management.comm | 5065 | 8 | 8 | ||||
| com.sun.management.internal.snmp | 1139 | 1 | 1 | ||||
| com.sun.management.jmx | 253 | 1 | 1 | ||||
| com.sun.management.snmp | 3181 | 3 | 3 | ||||
| com.sun.management.snmp.agent | 3857 | 3 | 3 | ||||
| com.sun.management.snmp.IPAcl | 3391 | 1 | 1 | ||||
| com.sun.management.snmp.manager | 3322 | 12 | 12 | ||||
| com.sun.management.snmp.uacl | 2047 | 1 | 1 | ||||
| com.sun.management.snmp.usm | 2137 | 1 | 1 | ||||
| com.sun.management.snmp.usm.usmmib | 1599 | 3 | 3 | ||||
| com.sun.messaging | 862 | 3 | 3 | ||||
| com.sun.messaging.jmq | 273 | 1 | 1 | ||||
| com.sun.messaging.jmq.admin.apps.console | 8812 | 4 | 4 | ||||
| com.sun.messaging.jmq.admin.bkrutil | 2450 | 2 | 2 | ||||
| com.sun.messaging.jmq.admin.jmsspi | 575 | 1 | 1 | ||||
| com.sun.messaging.jmq.auth.jaas | 274 | 1 | 1 | ||||
| com.sun.messaging.jmq.io | 6201 | 40 | 40 | ||||
| com.sun.messaging.jmq.jmsclient | 11921 | 6 | 6 | ||||
| com.sun.messaging.jmq.jmsclient.notification | 207 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsselector | 2820 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver | 2367 | 79 | 79 | ||||
| com.sun.messaging.jmq.jmsserver.auth | 648 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.auth.acl | 399 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.auth.file | 121 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.auth.jaas | 170 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.auth.ldap | 330 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.auth.usermgr | 1062 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.cluster | 941 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.config | 622 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.core | 8630 | 33 | 33 | ||||
| com.sun.messaging.jmq.jmsserver.core.cluster | 834 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.data | 1977 | 9 | 9 | ||||
| com.sun.messaging.jmq.jmsserver.data.handlers | 3332 | 26 | 26 | ||||
| com.sun.messaging.jmq.jmsserver.data.handlers.admin | 2953 | 6 | 6 | ||||
| com.sun.messaging.jmq.jmsserver.data.migration | 239 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.license | 498 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.management.agent | 1331 | 3 | 3 | ||||
| com.sun.messaging.jmq.jmsserver.management.jesmf | 863 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.management.mbeans | 3607 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.management.util | 1155 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker | 1321 | 7 | 7 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker.falcon | 1834 | 8 | 8 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker.fullyconnected | 2092 | 6 | 6 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker.heartbeat | 667 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker.raptor | 4000 | 11 | 11 | ||||
| com.sun.messaging.jmq.jmsserver.multibroker.raptor.handlers | 707 | 21 | 21 | ||||
| com.sun.messaging.jmq.jmsserver.net.http | 238 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.net.tcp | 397 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.net.tls | 141 | 3 | 3 | ||||
| com.sun.messaging.jmq.jmsserver.persist | 547 | 1 | 1 | ||||
| com.sun.messaging.jmq.jmsserver.persist.file | 4344 | 5 | 5 | ||||
| com.sun.messaging.jmq.jmsserver.persist.jdbc | 8895 | 3 | 3 | ||||
| com.sun.messaging.jmq.jmsserver.service | 1804 | 7 | 7 | ||||
| com.sun.messaging.jmq.jmsserver.service.imq | 2285 | 12 | 12 | ||||
| com.sun.messaging.jmq.jmsserver.service.imq.group | 912 | 4 | 4 | ||||
| com.sun.messaging.jmq.jmsserver.util | 798 | 2 | 2 | ||||
| com.sun.messaging.jmq.jmsserver.util.memory | 733 | 11 | 11 | ||||
| com.sun.messaging.jmq.jmsserver.util.memory.levels | 154 | 14 | 14 | ||||
| com.sun.messaging.jmq.jmsserver.util.pool | 614 | 3 | 3 | ||||
| com.sun.messaging.jmq.management | 99 | 1 | 1 | ||||
| com.sun.messaging.jmq.net | 250 | 1 | 1 | ||||
| com.sun.messaging.jmq.transport.httptunnel | 978 | 1 | 1 | ||||
| com.sun.messaging.jmq.transport.httptunnel.server | 376 | 3 | 3 | ||||
| com.sun.messaging.jmq.transport.httptunnel.servlet | 1012 | 1 | 1 | ||||
| com.sun.messaging.jmq.util | 2638 | 12 | 12 | ||||
| com.sun.messaging.jmq.util.lists | 2508 | 4 | 4 | ||||
| com.sun.messaging.jmq.util.log | 685 | 2 | 2 | ||||
| com.sun.messaging.jmq.util.timer | 242 | 1 | 1 | ||||
| com.sun.messaging.jms.logging | 62 | 1 | 1 | ||||
| com.sun.messaging.jms.ra | 3938 | 25 | 25 | ||||
| com.sun.mfwk.agent.appserv.util | 123 | 3 | 3 | ||||
| com.sun.msv.grammar.util | 340 | 3 | 3 | ||||
| com.sun.msv.reader.trex.ng | 994 | 3 | 3 | ||||
| com.sun.msv.writer.relaxng | 580 | 1 | 1 | ||||
| com.sun.org.apache.commons.beanutils | 2210 | 1 | 1 | ||||
| com.sun.org.apache.commons.collections | 6137 | 3 | 3 | ||||
| com.sun.org.apache.commons.logging.impl | 498 | 2 | 2 | ||||
| com.sun.org.apache.commons.modeler | 1849 | 2 | 2 | ||||
| com.sun.org.apache.commons.modeler.util | 622 | 1 | 1 | ||||
| com.sun.org.apache.xml.internal.resolver | 1510 | 2 | 2 | ||||
| com.sun.org.apache.xml.internal.resolver.helpers | 194 | 1 | 1 | ||||
| com.sun.org.apache.xml.internal.security.c14n.implementations | 777 | 1 | 1 | ||||
| com.sun.org.apache.xml.internal.security.keys.content.x509 | 180 | 4 | 4 | ||||
| com.sun.org.apache.xml.internal.security.utils | 1651 | 1 | 1 | ||||
| com.sun.tools.ws.processor.modeler.wsdl | 2513 | 4 | 4 | ||||
| com.sun.tools.ws.wsdl.document.jaxws | 227 | 1 | 1 | ||||
| com.sun.web.security | 1549 | 2 | 2 | ||||
| com.sun.web.ui.common | 2554 | 2 | 2 | ||||
| com.sun.web.ui.component | 24579 | 20 | 20 | ||||
| com.sun.web.ui.model | 7541 | 7 | 7 | ||||
| com.sun.web.ui.model.scheduler | 194 | 2 | 2 | ||||
| com.sun.web.ui.renderer | 9399 | 1 | 1 | ||||
| com.sun.web.ui.renderer.template.xml | 567 | 1 | 1 | ||||
| com.sun.web.ui.servlet.datetime | 176 | 1 | 1 | ||||
| com.sun.web.ui.servlet.filechooser | 179 | 2 | 2 | ||||
| com.sun.web.ui.servlet.help | 82 | 1 | 1 | ||||
| com.sun.web.ui.servlet.help2 | 947 | 2 | 2 | ||||
| com.sun.web.ui.servlet.table | 267 | 1 | 1 | ||||
| com.sun.web.ui.servlet.version | 79 | 1 | 1 | ||||
| com.sun.web.ui.servlet.wizard | 120 | 2 | 2 | ||||
| com.sun.web.ui.taglib.alarm | 135 | 1 | 1 | ||||
| com.sun.web.ui.taglib.alert | 384 | 1 | 1 | ||||
| com.sun.web.ui.taglib.common | 1004 | 1 | 1 | ||||
| com.sun.web.ui.taglib.datetime | 698 | 1 | 1 | ||||
| com.sun.web.ui.taglib.filechooser | 515 | 6 | 6 | ||||
| com.sun.web.ui.taglib.help | 660 | 1 | 1 | ||||
| com.sun.web.ui.taglib.masthead | 908 | 1 | 1 | ||||
| com.sun.web.ui.taglib.propertysheet | 801 | 1 | 1 | ||||
| com.sun.web.ui.taglib.skip | 96 | 1 | 1 | ||||
| com.sun.web.ui.taglib.version | 336 | 1 | 1 | ||||
| com.sun.web.ui.taglib.wizard | 665 | 1 | 1 | ||||
| com.sun.web.ui.theme | 1609 | 1 | 1 | ||||
| com.sun.web.ui.util | 3453 | 4 | 4 | ||||
| com.sun.webui.jsf.component | 38651 | 33 | 33 | ||||
| com.sun.webui.jsf.event | 586 | 2 | 2 | ||||
| com.sun.webui.jsf.model | 1515 | 3 | 3 | ||||
| com.sun.webui.jsf.model.scheduler | 226 | 2 | 2 | ||||
| com.sun.webui.jsf.renderkit.html | 10644 | 2 | 2 | ||||
| com.sun.webui.jsf.util | 2737 | 3 | 3 | ||||
| com.sun.webui.jsf.validator | 264 | 1 | 1 | ||||
| com.sun.webui.theme | 998 | 1 | 1 | ||||
| com.sun.xml.bind.v2 | 222 | 1 | 1 | ||||
| com.sun.xml.bind.v2.model.impl | 3228 | 1 | 1 | ||||
| com.sun.xml.fastinfoset.algorithm | 923 | 1 | 1 | ||||
| com.sun.xml.messaging.saaj.client.p2p | 386 | 2 | 2 | ||||
| com.sun.xml.messaging.saaj.soap | 2130 | 11 | 11 | ||||
| com.sun.xml.messaging.saaj.soap.impl | 1637 | 8 | 8 | ||||
| com.sun.xml.messaging.saaj.soap.name | 243 | 2 | 2 | ||||
| com.sun.xml.messaging.saaj.soap.ver1_1 | 497 | 6 | 6 | ||||
| com.sun.xml.messaging.saaj.soap.ver1_2 | 809 | 8 | 8 | ||||
| com.sun.xml.messaging.saaj.util | 1250 | 4 | 4 | ||||
| com.sun.xml.messaging.saaj.util.transform | 170 | 1 | 1 | ||||
| com.sun.xml.registry.common.tools | 686 | 2 | 2 | ||||
| com.sun.xml.registry.uddi | 4914 | 4 | 4 | ||||
| com.sun.xml.rpc.client.dii | 1892 | 1 | 1 | ||||
| com.sun.xml.rpc.encoding | 3785 | 1 | 1 | ||||
| com.sun.xml.rpc.encoding.soap | 1716 | 1 | 1 | ||||
| com.sun.xml.rpc.processor.generator | 10633 | 6 | 6 | ||||
| com.sun.xml.rpc.processor.modeler.j2ee.xml | 2371 | 1 | 1 | ||||
| com.sun.xml.rpc.processor.modeler.wsdl | 4848 | 3 | 3 | ||||
| com.sun.xml.rpc.server.http | 994 | 1 | 1 | ||||
| com.sun.xml.rpc.streaming | 2335 | 1 | 1 | ||||
| com.sun.xml.rpc.tools.ant | 585 | 2 | 2 | ||||
| com.sun.xml.rpc.util | 1568 | 2 | 2 | ||||
| com.sun.xml.stream | 6943 | 2 | 2 | ||||
| com.sun.xml.stream.buffer | 679 | 1 | 1 | ||||
| com.sun.xml.stream.util | 97 | 3 | 3 | ||||
| com.sun.xml.stream.xerces.util | 3301 | 1 | 1 | ||||
| com.sun.xml.txw2.output | 856 | 1 | 1 | ||||
| com.sun.xml.ws.api.client | 99 | 4 | 4 | ||||
| com.sun.xml.ws.api.pipe | 687 | 1 | 1 | ||||
| com.sun.xml.ws.encoding | 1308 | 1 | 1 | ||||
| com.sun.xml.ws.rm.jaxws.runtime | 415 | 1 | 1 | ||||
| com.sun.xml.ws.rm.jaxws.runtime.server | 710 | 1 | 1 | ||||
| com.sun.xml.ws.security.impl.policy | 3850 | 1 | 1 | ||||
| com.sun.xml.ws.security.opt.crypto.dsig | 829 | 2 | 2 | ||||
| com.sun.xml.ws.security.opt.impl | 122 | 1 | 1 | ||||
| com.sun.xml.ws.security.opt.impl.dsig | 1460 | 2 | 2 | ||||
| com.sun.xml.ws.security.opt.impl.enc | 771 | 3 | 3 | ||||
| com.sun.xml.ws.security.opt.impl.incoming | 3347 | 3 | 3 | ||||
| com.sun.xml.ws.security.opt.impl.keyinfo | 1008 | 1 | 1 | ||||
| com.sun.xml.ws.security.opt.impl.util | 1032 | 3 | 3 | ||||
| com.sun.xml.ws.security.trust | 273 | 1 | 1 | ||||
| com.sun.xml.ws.security.trust.impl.elements | 1671 | 3 | 3 | ||||
| com.sun.xml.ws.transport.tcp.util | 705 | 1 | 1 | ||||
| com.sun.xml.ws.tx.at | 1243 | 1 | 1 | ||||
| com.sun.xml.ws.tx.coordinator | 593 | 2 | 2 | ||||
| com.sun.xml.ws.tx.webservice.member.at | 437 | 2 | 2 | ||||
| com.sun.xml.ws.tx.webservice.member.coord | 360 | 3 | 3 | ||||
| com.sun.xml.ws.util | 1374 | 21 | 21 | ||||
| com.sun.xml.wss.core | 2953 | 11 | 11 | ||||
| com.sun.xml.wss.core.reference | 363 | 3 | 3 | ||||
| com.sun.xml.wss.impl | 3098 | 15 | 15 | ||||
| com.sun.xml.wss.impl.apachecrypto | 1582 | 4 | 4 | ||||
| com.sun.xml.wss.impl.c14n | 1811 | 1 | 1 | ||||
| com.sun.xml.wss.impl.config | 1625 | 2 | 2 | ||||
| com.sun.xml.wss.impl.filter | 1029 | 5 | 5 | ||||
| com.sun.xml.wss.impl.keyinfo | 271 | 5 | 5 | ||||
| com.sun.xml.wss.impl.misc | 4826 | 4 | 4 | ||||
| com.sun.xml.wss.impl.policy.mls | 1853 | 1 | 1 | ||||
| com.sun.xml.wss.impl.policy.verifier | 392 | 2 | 2 | ||||
| com.sun.xml.wss.impl.resolver | 312 | 2 | 2 | ||||
| com.sun.xml.wss.impl.transform | 1001 | 3 | 3 | ||||
| com.sun.xml.wss.jaxws.impl | 1682 | 8 | 8 | ||||
| com.sun.xml.wss.provider | 611 | 2 | 2 | ||||
| com.sun.xml.wss.provider.wsit | 1885 | 9 | 9 | ||||
| com.sun.xml.wss.saml | 286 | 2 | 2 | ||||
| com.sun.xml.wss.saml.assertion.saml11.jaxb10 | 596 | 18 | 18 | ||||
| com.sun.xml.wss.saml.assertion.saml11.jaxb20 | 574 | 17 | 17 | ||||
| com.sun.xml.wss.saml.assertion.saml20.jaxb20 | 620 | 18 | 18 | ||||
| com.sun.xml.wss.saml.impl | 316 | 1 | 1 | ||||
| com.sun.xml.wss.saml.util | 124 | 2 | 2 | ||||
| javax.faces.application | 355 | 1 | 1 | ||||
| javax.faces.webapp | 1136 | 1 | 1 | ||||
| javax.help | 6988 | 5 | 5 | ||||
| javax.help.plaf.basic | 3676 | 4 | 4 | ||||
| javax.management | 3214 | 1 | 1 | ||||
| javax.management.relation | 3027 | 2 | 2 | ||||
| javax.management.remote | 646 | 1 | 1 | ||||
| javax.persistence | 507 | 1 | 1 | ||||
| javax.servlet.jsp.jstl.core | 448 | 1 | 1 | ||||
| javax.servlet.jsp.tagext | 613 | 1 | 1 | ||||
| javax.wsdl | 262 | 4 | 4 | ||||
| javax.xml.registry.samples | 125 | 1 | 1 | ||||
| net.jxta.impl.document | 1051 | 4 | 4 | ||||
| net.jxta.impl.endpoint | 1979 | 5 | 5 | ||||
| net.jxta.impl.endpoint.cbjx | 462 | 1 | 1 | ||||
| net.jxta.impl.endpoint.router | 2426 | 1 | 1 | ||||
| net.jxta.impl.endpoint.tcp | 1023 | 1 | 1 | ||||
| net.jxta.impl.endpoint.tls | 1676 | 1 | 1 | ||||
| net.jxta.impl.id.binaryID | 694 | 3 | 3 | ||||
| net.jxta.impl.peergroup | 3217 | 3 | 3 | ||||
| net.jxta.impl.proxy | 738 | 1 | 1 | ||||
| net.jxta.impl.rendezvous.adhoc | 115 | 1 | 1 | ||||
| net.jxta.impl.xindice.core.filer | 1586 | 6 | 6 | ||||
| net.jxta.meter | 519 | 4 | 4 | ||||
| net.jxta.platform | 529 | 1 | 1 | ||||
| net.jxta.protocol | 1736 | 1 | 1 | ||||
| net.jxta.util | 1620 | 1 | 1 | ||||
| oracle.toplink.essentials.descriptors | 3700 | 1 | 1 | ||||
| oracle.toplink.essentials.internal.ejb.cmp3.metadata | 1446 | 1 | 1 | ||||
| oracle.toplink.essentials.internal.ejb.cmp3.metadata.sequencing | 117 | 3 | 3 | ||||
| oracle.toplink.essentials.internal.ejb.cmp3.transaction.base | 364 | 1 | 1 | ||||
| oracle.toplink.essentials.internal.ejb.cmp3.xml.accessors | 462 | 6 | 6 | ||||
| oracle.toplink.essentials.internal.helper | 4347 | 5 | 5 | ||||
| oracle.toplink.essentials.internal.parsing.ejbql | 197 | 1 | 1 | ||||
| oracle.toplink.essentials.internal.queryframework | 3613 | 1 | 1 | ||||
| oracle.toplink.essentials.internal.sessions | 5780 | 4 | 4 | ||||
| oracle.toplink.essentials.logging | 854 | 2 | 2 | ||||
| oracle.toplink.essentials.mappings | 5693 | 3 | 3 | ||||
| oracle.toplink.essentials.queryframework | 3811 | 2 | 2 | ||||
| oracle.toplink.essentials.sequencing | 532 | 4 | 4 | ||||
| oracle.toplink.essentials.sessions | 2186 | 1 | 1 | ||||
| org.apache.bcel | 483 | 11 | 11 | ||||
| org.apache.bcel.generic | 6517 | 6 | 6 | ||||
| org.apache.bcel.util | 1550 | 3 | 3 | ||||
| org.apache.bcel.verifier | 926 | 2 | 2 | ||||
| org.apache.bcel.verifier.structurals | 2700 | 5 | 5 | ||||
| org.apache.commons.httpclient | 5323 | 4 | 4 | ||||
| org.apache.commons.logging.impl | 703 | 1 | 1 | ||||
| org.apache.naming | 835 | 1 | 1 | ||||
| org.apache.naming.factory | 317 | 1 | 1 | ||||
| org.apache.regexp | 1584 | 1 | 1 | ||||
| org.apache.xml.resolver | 1319 | 1 | 1 | ||||
| org.apache.xml.resolver.apps | 423 | 1 | 1 | ||||
| org.apache.xml.resolver.tools | 370 | 2 | 2 | ||||
| org.apache.xmlbeans | 6180 | 1 | 1 | ||||
| org.apache.xmlbeans.impl.common | 2855 | 2 | 2 | ||||
| org.apache.xmlbeans.impl.schema | 10433 | 2 | 2 | ||||
| org.apache.xmlbeans.impl.store | 8394 | 4 | 4 | ||||
| org.apache.xmlbeans.impl.tool | 3609 | 8 | 8 | ||||
| org.apache.xmlbeans.impl.values | 4256 | 2 | 2 | ||||
| org.javagroups | 1670 | 3 | 3 | ||||
| org.javagroups.blocks | 6508 | 5 | 5 | ||||
| org.javagroups.debug | 293 | 2 | 2 | ||||
| org.javagroups.demos | 3842 | 2 | 2 | ||||
| org.javagroups.demos.wb | 586 | 1 | 1 | ||||
| org.javagroups.ensemble | 1048 | 4 | 4 | ||||
| org.javagroups.persistence | 461 | 1 | 1 | ||||
| org.javagroups.protocols | 11130 | 14 | 14 | ||||
| org.javagroups.protocols.pbcast | 3417 | 3 | 3 | ||||
| org.javagroups.protocols.ring | 398 | 5 | 5 | ||||
| org.javagroups.stack | 3087 | 4 | 4 | ||||
| org.javagroups.tests | 7132 | 10 | 10 | ||||
| org.javagroups.util | 2000 | 8 | 8 | ||||
| org.jcp.xml.dsig.internal.dom | 3015 | 16 | 16 | ||||
| org.jgroups | 1793 | 5 | 5 | ||||
| org.jgroups.blocks | 6743 | 9 | 9 | ||||
| org.jgroups.conf | 789 | 2 | 2 | ||||
| org.jgroups.debug | 307 | 2 | 2 | ||||
| org.jgroups.ensemble | 1075 | 4 | 4 | ||||
| org.jgroups.persistence | 536 | 1 | 1 | ||||
| org.jgroups.protocols | 12716 | 11 | 11 | ||||
| org.jgroups.protocols.pbcast | 3618 | 3 | 3 | ||||
| org.jgroups.protocols.ring | 405 | 5 | 5 | ||||
| org.jgroups.stack | 3953 | 10 | 10 | ||||
| org.jgroups.util | 3051 | 20 | 20 | ||||
| org.netbeans.modules.dbschema | 1532 | 3 | 3 | ||||
| org.netbeans.modules.dbschema.jdbcimpl | 1449 | 1 | 1 | ||||
| org.netbeans.modules.dbschema.migration.archiver.deserializer | 810 | 1 | 1 | ||||
| org.netbeans.modules.schema2beans | 6691 | 6 | 6 | ||||
| sun.rmi.rmic.iiop | 5670 | 1 | 1 |
This cast will always throw a ClassCastException.
Loads a value from a byte array and performs a bitwise OR with that value. Values loaded from byte arrays are signed bytes, and thus this may not give the desired results.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
This method invokes the .equals(Object o) to compare an array and a reference that doesn't seem to be an array. If things being compared are of different types, they are guaranteed to be unequal and the comparison is almost certainly an error. Even if they are both arrays, the equals method on arrays only determines of the two arrays are the same object. To compare the contents of the arrays, use java.util.Arrays.equals(Object[], Object[]).
This method calls equals(Object) on two references, one of which is a class and the other an interface, where neither the class nor any of its non-abstract subclasses implement the interface. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This code compares java.lang.String objects for reference
equality using the == or != operators.
Unless both strings are either constants in a source file, or have been
interned using the String.intern() method, the same string
value may be represented by two different String objects. Consider
using the equals(Object) method instead.
This code compares java.lang.String objects for reference
equality using the == or != operators.
Unless both strings are either constants in a source file, or have been
interned using the String.intern() method, the same string
value may be represented by two different String objects. Consider
using the equals(Object) method instead.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This method assigns a literal boolean value (true or false) to a boolean variable inside an if or while expression. Most probably this was supposed to be a boolean comparison using ==, not an assignment using =.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This code generates a random signed integer and then computes the remainder of that value modulo another value. Since the random number can be negative, the result of the remainder operation can also be negative. Be sure this is intended, and strongly consider using the Random.nextInt(int) method instead.
This code generates a random signed integer and then computes the remainder of that value modulo another value. Since the random number can be negative, the result of the remainder operation can also be negative. Be sure this is intended, and strongly consider using the Random.nextInt(int) method instead.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
Waiting on a monitor while two locks are held may cause deadlock. Performing a wait only releases the lock on the object being waited on, not any other locks. This not necessarily a bug, but is worth examining closely.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
The code creates an SQL prepared statement from a nonconstant String. If unchecked, tainted data from a user is used in building this String, SQL injection could be used to make the prepared statement do something unexpected and undesirable.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method invokes the .equals(Object o) to compare an array and a reference that doesn't seem to be an array. If things being compared are of different types, they are guaranteed to be unequal and the comparison is almost certainly an error. Even if they are both arrays, the equals method on arrays only determines of the two arrays are the same object. To compare the contents of the arrays, use java.util.Arrays.equals(Object[], Object[]).
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This code generates a random signed integer and then computes the remainder of that value modulo another value. Since the random number can be negative, the result of the remainder operation can also be negative. Be sure this is intended, and strongly consider using the Random.nextInt(int) method instead.
This code generates a random signed integer and then computes the remainder of that value modulo another value. Since the random number can be negative, the result of the remainder operation can also be negative. Be sure this is intended, and strongly consider using the Random.nextInt(int) method instead.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This code compares java.lang.String objects for reference
equality using the == or != operators.
Unless both strings are either constants in a source file, or have been
interned using the String.intern() method, the same string
value may be represented by two different String objects. Consider
using the equals(Object) method instead.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method calls equals(Object) on two references, one of which is a class and the other an interface, where neither the class nor any of its non-abstract subclasses implement the interface. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This code compares java.lang.String objects for reference
equality using the == or != operators.
Unless both strings are either constants in a source file, or have been
interned using the String.intern() method, the same string
value may be represented by two different String objects. Consider
using the equals(Object) method instead.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
A non-serializable value is stored into a non-transient field of a serializable class.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Loads a value from a byte array and performs a bitwise OR with that value. Values loaded from byte arrays are signed bytes, and thus this may not give the desired results.
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A non-serializable value is stored into a non-transient field of a serializable class.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class implements the Serializable interface
and its superclass does not. When such an object is deserialized,
the fields of the superclass need to be initialized by
invoking the void constructor of the superclass.
Since the superclass does not have one,
serialization and deserialization will fail at runtime.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This method acquires a JSR-166 (java.util.concurrent) lock,
but does not release it on all paths out of the method. In general, the correct idiom
for using a JSR-166 lock is:
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class defines a field with the same name as a visible instance field in a superclass. This is confusing, and may indicate an error if methods update or access one of the fields when they wanted the other.
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
This method unconditionally invokes itself. This would seem to indicate an infinite recursive loop that will result in a stack overflow.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method uses a try-catch block that catches Exception objects, but Exception is not thrown within the try block, and RuntimeException is not explicitly caught. It is a common bug pattern to say try { ... } catch (Exception e) { something } as a shorthand for catching a number of types of exception each of whose catch blocks is identical, but this construct also accidentally catches RuntimeException as well, masking potential bugs.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This cast will always throw a ClassCastException.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
All writes to this field are of the constant value null, and thus all reads of the field will return null. Check for errors, or remove it if it is useless.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
There is an integer comparison that always returns the same value (e.g., x <= Integer.MAX_VALUE).
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class defines a method called hashcode(). This method
does not override the hashCode() method in java.lang.Object,
which is probably what was intended.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
This class implements the Serializable interface, and defines a method
for custom serialization/deserialization. But since that method isn't declared private,
it will be silently ignored by the serialization/deserialization API.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
The return value of this method should be checked. One common cause of this warning is to invoke a method on an immutable object, thinking that it updates the object. For example, in the following code fragment,
String dateString = getHeaderField(name); dateString.trim();
the programer seems to be thinking that the trim() method will update the String referenced by dateString. But since Strings are immutable, the trim() function returns a new String value, which is being ignored here. The code should be corrected to:
String dateString = getHeaderField(name); dateString = dateString.trim();
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method calls equals(Object) on two references of different class types with no common subclasses. Therefore, the objects being compared are unlikely to be members of the same class at runtime (unless some application classes were not analyzed, or dynamic class loading can occur at runtime). According to the contract of equals(), objects of different classes should always compare as unequal; therefore, according to the contract defined by java.lang.Object.equals(Object), the result of this comparison will always be false at runtime.
A null pointer is dereferenced here. This will lead to a
NullPointerException when the code is executed.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method assigns a literal boolean value (true or false) to a boolean variable inside an if or while expression. Most probably this was supposed to be a boolean comparison using ==, not an assignment using =.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The method invokes the execute method on an SQL statement with a String that seems to be dynamically generated. Consider using a prepared statement instead. It is more efficient and less vulnerable to SQL injection attacks.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A final static field references an array and can be accessed by malicious code or by accident from another package. This code can freely modify the contents of the array.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This Serializable class defines a non-primitive instance field which is neither transient,
Serializable, or java.lang.Object, and does not appear to implement
the Externalizable interface or the
readObject() and writeObject() methods.
Objects of this class will not be deserialized correctly if a non-Serializable
object is stored in this field.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
The referenced methods have names that differ only by capitalization. It is very confusing because the classes that contain these methods are related by inheritance.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This method might ignore an exception. In general, exceptions should be handled or reported in some way, or they should be thrown out of the method.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class defines a covariant version of the equals()
method, but inherits the normal equals(Object) method
defined in the base java.lang.Object class.
The class should probably define a non-covariant version of equals().
(I.e., a method with the signature boolean equals(java.lang.Object).
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A value is checked here to see whether it is null, but this value can't be null because it was previously dereferenced and if it were null a null pointer exception would have occurred at the earlier dereference. Essentially, this code and the previous dereference disagree as to whether this value is allowed to be null. Either the check is redundant or the previous dereference is erroneous.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
Code explicitly invokes garbage collection. Except for specific use in benchmarking, this is very dubious.
In the past, situations where people have explicitly invoked the garbage collector in routines such as close or finalize methods has led to huge performance black holes. Garbage collection can be expensive. Any situation that forces hundreds or thousands of garbage collections will bring the machine to a crawl.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
This code seems to be passing a non-serializable object to the ObjectOutput.writeObject method. If the object is, indeed, non-serializable, an error will result.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This instruction assigns a value to a local variable, but the value is not read by any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
This instance method writes to a static field. This is tricky to get correct if multiple instances are being manipulated, and generally bad practice.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
A mutable static field could be changed by malicious code or by accident from another package. The field could be made final to avoid this vulnerability.
This class overrides equals(Object), but does not
override hashCode(), and inherits the implementation of
hashCode() from java.lang.Object (which returns
the identity hash code, an arbitrary value assigned to the object
by the VM). Therefore, the class is very likely to violate the
invariant that equal objects must have equal hashcodes.
If you don't think instances of this class will ever be inserted into a HashMap/HashTable,
the recommended hashCode implementation to use is:
public int hashCode() {
assert false : "hashCode not designed";
return 42; // any arbitrary constant will do
}